(1) Field of the Invention
The present invention relates in general to distributed software systems, and more specifically to a method and apparatus for creating Client and Consumer Implementations in a Common Object Request Broker Architecture (CORBA) based distributed software system where the Client and Consumer Implementations interact with any existing Servers and/or Suppliers/event channels (Suppliers) in the system, and display the data resulting from the interactions for the purpose of validating the operation, functionality and performance of the Servers and Suppliers.
(2) Description of the Prior Art
A common data processing system design utilizes a distributed computing environment where data is managed and disseminated over two or more interconnected computers. Such an interconnection of computers with the ability to communicate information between the computers is known as a computer network, or simply a network. Such networks may include a large number of components, including various types of computers and peripheral devices, which may be configured in a variety of ways and may be characterized as “Local Area Networks” (LANs) or “Wide Area Networks” (WANs) based on the geographic area over which the components are distributed. LANs and WANs often employ standard common configurations or architectures. For example, in a standard Client/Server configuration a certain number of the interconnected computers may function as Clients while others may function as Servers that provide services to the Clients. Such a Client/Server configuration is a common example of one of the several available configurations of distributed computing environments (LANs and WANs) and is well known by those skilled in the art.
One manner of implementing software applications to run on a LAN or WAN is to use a vendor-independent network software architecture and infrastructure that various heterogeneous software applications can use to work together over the network. Such an implementation can be achieved using the “Common Object Request Broker Architecture” (CORBA) Specification. CORBA is a vendor independent specification for an architecture and infrastructure that promotes interoperability within a distributed software system. It integrates computers from different vendors ranging in size from mainframes to desktops. CORBA provides a software bus that enables system applications to exchange and communicate information where such applications typically are distributed across a LAN or WAN. A CORBA based system relies on data abstraction to permit software applications running on the system to function unconstrained by the underlying network details, such as the types of workstations, the types of operating systems, and/or the languages of other application implementations. One of CORBA's most important, as well as most frequent uses is in Servers that must handle a large number of Clients, at high hit rates with high reliability. Applications utilizing the CORBA infrastructure are typically implemented and configured as either providers of data (Servers and Suppliers) or users of data (Clients and Consumers). Reference to either Client or Consumer hereinafter will be understood to also include the other term unless specified otherwise.
A large-scale distributed software system utilizing CORBA based architecture may have hundreds or even thousands of Servers and/or Suppliers. Development of such a large-scale distributed software system would ideally involve incremental integration of the system on a network. During this sort of integration the operations of the Servers and Suppliers need to be validated before the Clients and Consumers are installed on to the system. If the operations of the Servers and Suppliers are determined to be in error, the system will require debugging before integration can continue. During incremental integration, developers need to verify the initialization of Servers and Suppliers as well as connectivity and data interactions between the Servers/Suppliers and Clients/Consumers. They need to take relevant performance measurements such as the time to initialize, the time required for Servers to respond to Client invocations and the frequency rate of Suppliers providing data. They also need to verify that data obtained from the Servers and Suppliers is within specified ranges.
Although software tools presently exist for gathering a variety of data from Servers and/or Suppliers in a distributed software system, they do not employ existing CORBA resources to achieve their results in real time, rather they often require additional performance monitoring code to be incorporated into each Server/Supplier application.
There currently does not exist a method and apparatus that can non-intrusively assist a software developer in validating the operations of and debugging any of the Servers and Suppliers in a CORBA based system during incremental integration of the system that avoids incorporating performance-monitoring code into each Server/Supplier application.
What is needed is a Universal Client and Consumer software tool that rather than incorporating additional code exploits existing CORBA resources for the purpose of validating the operation, functionality and performance of any of the Servers and Suppliers in a CORBA based distributed software system.